import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../common/utils/index.dart';
import '../../../common/routers/index.dart';
import '../../../common/services/index.dart';

class MainController extends GetxController {
  // 1. 静态常量（类级别）
  static const String tag = 'MainController';
  
  // 2. 响应式变量（Rx系列）
  // 基础类型 - 使用.obs写法（最常用，推荐95%场景使用）
  var isLoading = false.obs;                   // RxBool
  var currentIndex = 0.obs;                    // RxInt - 默认显示首页（索引0）
  var currentPageTitle = '首页'.obs;             // RxString - 默认标题为首页
  
  // 集合类型 - 使用.obs写法
  var userSettings = <String, dynamic>{}.obs;  // RxMap<String, dynamic>
  
  // 可空类型 - 特殊场景使用（约5%场景）
  var selectedMenuIndex = RxnInt();            // 可空整数，初始为null
  
  // 3. 普通变量（非响应式）
  bool _isInitialized = false;
  
  // 路由映射表 - 将底部导航项与路由名称关联
  // 新顺序：首页、发现、消息、我的（测试页移除）
  final List<String> _routes = [
    RouteNames.homeHomeIndex,          // 首页
    RouteNames.discoverDiscoverIndex,  // 发现页
    RouteNames.messageMessageIndex,    // 消息页
    RouteNames.myMyIndex,              // 我的页面
  ];
  
  // 4. 控制器和服务依赖
  late AppLifecycleManager _lifecycleManager;
  late UserService _userService;
  
  // 5. 构造函数
  MainController() {
    debugPrint('$tag: Constructor');
    // 立即同步到首页状态（解决permanent控制器生命周期问题）
    _setHomePageState();
  }

  /// 设置首页状态（统一方法）
  void _setHomePageState({bool recordRoute = false}) {
    debugPrint('$tag: 设置首页状态');
    
    currentIndex.value = 0;
    currentPageTitle.value = '首页';
    selectedMenuIndex.value = 0;
    
    // 可选记录路由
    if (recordRoute) {
      _recordTabRoute(0);
    }
    
    debugPrint('$tag: ✅ 首页状态设置完成 - 索引: ${currentIndex.value}');
  }

  // 6. 私有初始化方法
  void _initData() {
    debugPrint('$tag: 🚀 开始初始化主页数据');
    
    // 初始化用户设置
    userSettings.assignAll({
      'theme': 'light',
      'language': 'zh_CN',
      'notifications': true,
    });
    
    // 设置首页状态并记录路由
    _setHomePageState(recordRoute: true);
    
    // 同步最新用户信息
    _syncUserProfile();
    
    _isInitialized = true;
    update(["main"]);
    
    debugPrint('$tag: ✅ 主页数据初始化完成');
  }

  /// 同步最新用户信息
  /// 
  /// 在主页启动时获取最新用户信息，确保多设备数据同步
  /// 这是企业级应用的标准做法，解决用户在其他设备修改信息后的同步问题
  /// 登录状态检查已由 UserService.getUserProfile() 内部处理
  void _syncUserProfile() async {
    try {
      debugPrint('$tag: 🔄 开始同步最新用户信息');
      
      // 🚀 直接调用UserService，登录状态检查交由服务层处理
      final userProfile = await _userService.getUserProfile();
      
      debugPrint('$tag: ✅ 用户信息同步成功');
      debugPrint('$tag: 用户昵称: ${userProfile.nickName}');
      debugPrint('$tag: 用户邮箱: ${userProfile.email ?? "未设置"}');
      debugPrint('$tag: 用户手机: ${userProfile.phonenumber ?? "未设置"}');
      
      // 可选：显示同步成功的提示（一般不需要，避免打扰用户）
      // Get.snackbar(
      //   '信息已更新',
      //   '用户信息已同步最新版本',
      //   snackPosition: SnackPosition.TOP,
      //   duration: const Duration(seconds: 1),
      //   backgroundColor: Colors.green.withOpacity(0.1),
      // );
      
    } catch (e) {
      // 🎯 统一的错误处理，包括未登录和网络异常等情况
      final errorMsg = e.toString();
      
      if (errorMsg.contains('未登录')) {
        debugPrint('$tag: 用户未登录，跳过用户信息同步');
        // 未登录是正常情况，不需要显示错误
      } else {
        debugPrint('$tag: ⚠️ 用户信息同步失败: $e');
        
        // 网络异常等其他错误，在开发环境显示提示
        if (kDebugMode) {
          LoadingUtil.info('用户信息同步失败，使用本地缓存信息');
        }
      }
    }
  }

  // 8. 生命周期回调方法
  
  /// 初始化生命周期回调
  void _initLifecycleCallbacks() {
    debugPrint('$tag: 初始化生命周期回调');
    
    // 获取生命周期管理器实例
    _lifecycleManager = Get.find<AppLifecycleManager>();
    
    // 注册主页面专用的生命周期回调
    _lifecycleManager.addForegroundCallback(_onAppForeground);
    _lifecycleManager.addBackgroundCallback(_onAppBackground);
    _lifecycleManager.addStateChangeCallback(_onAppStateChange);
    
    debugPrint('$tag: 生命周期回调注册完成');
  }
  
  /// 清理生命周期回调
  void _clearLifecycleCallbacks() {
    debugPrint('$tag: 清理生命周期回调');
    
    try {
      _lifecycleManager.removeForegroundCallback(_onAppForeground);
      _lifecycleManager.removeBackgroundCallback(_onAppBackground);
      _lifecycleManager.removeStateChangeCallback(_onAppStateChange);
      
      debugPrint('$tag: 生命周期回调清理完成');
    } catch (e) {
      debugPrint('$tag: 清理生命周期回调时出错: $e');
    }
  }
  
  /// 应用回到前台时的处理
  void _onAppForeground() {
    debugPrint('$tag: 应用回到前台 - 主页面处理');
    
    // 可以在这里添加前台逻辑
    // 例如：刷新当前页面数据、恢复定时器、检查更新等
    if (_isInitialized) {
      // 刷新当前页面的数据
      _refreshCurrentPageData();
      
      // 同步最新用户信息（用户可能在其他设备修改了信息）
      _syncUserProfile();
    }
  }
  
  /// 应用进入后台时的处理
  void _onAppBackground() {
    debugPrint('$tag: 应用进入后台 - 主页面处理');
    
    // 可以在这里添加后台逻辑
    // 例如：保存数据、暂停定时器、清理敏感信息等
    if (_isInitialized) {
      // 保存当前状态
      _saveCurrentState();
    }
  }
  
  /// 应用状态变化时的处理
  void _onAppStateChange(AppState oldState, AppState newState) {
    debugPrint('$tag: 应用状态变化 ${oldState.name} → ${newState.name}');
    
    // 根据状态变化执行相应逻辑
    switch (newState) {
      case AppState.foreground:
        // 进入前台逻辑
        break;
      case AppState.background:
        // 进入后台逻辑
        break;
      case AppState.inactive:
        // 非活跃状态逻辑（如来电话时）
        break;
      case AppState.detached:
        // 应用即将被销毁
        break;
    }
  }
  
  /// 刷新当前页面数据（预留扩展）
  void _refreshCurrentPageData() {
    debugPrint('$tag: 刷新页面数据 - 当前索引: ${currentIndex.value}');
    // TODO: 各页面刷新逻辑待实现
  }
  
  /// 保存当前状态（预留扩展）
  void _saveCurrentState() {
    debugPrint('$tag: 保存当前状态');
    // TODO: 实际保存逻辑待实现
  }

  // 9. 业务方法
  
  /// 处理底部导航切换
  /// 注意：使用jumpToPage直接跳转，避免经过中间页面
  /// 对于需要登录的页面（消息和我的），会先检查登录状态
  void onBottomNavTap(int index) {
    debugPrint('$tag: 底部导航切换 - 索引: $index');
    
    if (!_isInitialized) return;
    
    if (currentIndex.value == index) return; // 如果是同一个tab，不切换
    
    // 检查是否需要登录认证的页面
    if (_requiresLogin(index)) {
      if (!_userService.isLoggedIn) {
        debugPrint('$tag: 页面需要登录，用户未登录，跳转到登录页');
        _handleLoginRequired(index);
        return;
      }
    }
    
    // 执行正常的页面切换
    _performTabSwitch(index);
  }
  
  /// 检查指定索引的页面是否需要登录
  bool _requiresLogin(int index) {
    // 索引 2 是消息页，索引 3 是我的页面，需要登录
    return index == 2 || index == 3;
  }
  
  /// 处理需要登录的情况
  void _handleLoginRequired(int targetIndex) {
    debugPrint('$tag: 处理登录要求 - 目标页面索引: $targetIndex');
    
    try {
      // 保存用户想要访问的页面路由，登录成功后可以返回
      final targetRoute = _routes[targetIndex];
      final storageService = Get.find<StorageService>();
      storageService.setString('redirect_route', targetRoute);
      
      debugPrint('$tag: 已保存重定向路由: $targetRoute');
      
      // 跳转到登录页面
      Get.toNamed(RouteNames.systemLogin);
      
    } catch (e) {
      debugPrint('$tag: 处理登录跳转失败: $e');
      // 如果跳转失败，显示提示信息
      LoadingUtil.info('请先登录后再访问该页面');
    }
  }
  
  /// 执行正常的页面切换
  void _performTabSwitch(int index) {
    debugPrint('$tag: 执行页面切换 - 索引: $index');
    
    selectedMenuIndex.value = index;
    currentIndex.value = index;
    
    // 记录标签页路由历史（虚拟路由记录）
    _recordTabRoute(index);
    
    // 更新标题
    _handleTabSwitch(index);
    
    debugPrint('$tag: ✅ 页面切换完成 - 当前索引: $index, 标题: ${currentPageTitle.value}');
    update(["main"]);
  }
  
  /// 处理标签切换（统一方法）
  void _handleTabSwitch(int index) {
    final tabTitles = ['首页', '发现', '消息', '我的'];
    
    if (index >= 0 && index < tabTitles.length) {
      currentPageTitle.value = tabTitles[index];
      debugPrint('$tag: 切换到${tabTitles[index]}');
    } else {
      debugPrint('$tag: 未知的标签索引: $index');
    }
  }
  
  /// 记录标签页路由
  /// 
  /// [index] 标签页索引
  void _recordTabRoute(int index) {
    if (index >= 0 && index < _routes.length) {
      final routeName = _routes[index];
      
      debugPrint('$tag: 跳转到路由: $routeName');
      debugPrint('$tag: 记录虚拟路由 - 索引: $index, 路由: $routeName');
      
      // 记录虚拟路由，不实际导航
      RoutePages.addHistory(routeName);
      
      // 如果需要调试路由历史，只显示最近10条记录
      if (kDebugMode && RoutePages.history.isNotEmpty) {
        try {
          final routeService = Get.find<RouteService>();
          final recentHistory = routeService.getRecentRoutes(10);
          final totalCount = routeService.history.length;
          
          debugPrint('$tag: 当前路由历史: $recentHistory');
          debugPrint('$tag: 当前路由: ${routeService.currentRoute}');
          debugPrint('$tag: 上一个路由: ${routeService.previousRoute}');
          
          if (totalCount > 10) {
            debugPrint('$tag: ⚠️  仅显示最近10条，总计${totalCount}条记录');
          }
        } catch (e) {
          debugPrint('$tag: 获取路由历史失败: $e');
        }
      }
    } else {
      debugPrint('$tag: 无效的标签页索引: $index');
    }
  }
  
  /// 刷新页面数据
  void refreshData() async {
    debugPrint('$tag: 开始刷新数据');
    
    try {
      isLoading.value = true;
      update(["main"]);
      
      // 模拟数据加载
      await Future.delayed(const Duration(seconds: 1));
      
      // 重新初始化数据
      _initData();
      
      debugPrint('$tag: 数据刷新完成');
      
    } catch (e) {
      debugPrint('$tag: 数据刷新失败: $e');
    } finally {
      isLoading.value = false;
      update(["main"]);
    }
  }
  
  /// 重置页面状态
  void resetState() {
    debugPrint('$tag: 重置页面状态');
    
    isLoading.value = false;
    _setHomePageState();
    selectedMenuIndex.value = null;
    
    update(["main"]);
  }
  
  /// 打印路由历史信息（调试用）
  /// 
  /// [displayLimit] 显示限制数量，默认10条
  void printRouteHistory({int displayLimit = 10}) {
    if (!kDebugMode) return;
    
    debugPrint('$tag: ========== 底部导航路由历史 ==========');
    debugPrint('$tag: 当前索引: ${currentIndex.value}');
    debugPrint('$tag: 当前标题: ${currentPageTitle.value}');
    debugPrint('$tag: 路由映射: $_routes');
    
    try {
      final routeService = Get.find<RouteService>();
      
      // 使用新的格式化方法，只显示最近指定数量的记录
      final info = routeService.getFormattedRouteInfo(displayLimit: displayLimit);
      
      debugPrint('$tag: 当前路由: ${info['current_route']}');
      debugPrint('$tag: 上一个路由: ${info['previous_route']}');
      debugPrint('$tag: 最近${info['displayed_count']}条历史: ${info['recent_history']}');
      debugPrint('$tag: 总历史记录数: ${info['total_count']}');
      debugPrint('$tag: 可以返回: ${info['can_go_back']}');
      
      if (info['is_truncated']) {
        debugPrint('$tag: ⚠️  历史记录已截断，仅显示最近${displayLimit}条');
      }
      
    } catch (e) {
      debugPrint('$tag: 获取路由服务失败: $e');
    }
    
    debugPrint('$tag: ==========================================');
  }


  /// 退出登录后重置到首页状态
  /// 供其他控制器调用的公开方法
  void resetToHomeAfterLogout() {
    debugPrint('$tag: 🔄 执行退出登录后的状态重置');
    
    _setHomePageState(recordRoute: true);
    update(["main"]);
    
    debugPrint('$tag: 🏠 退出登录状态重置完成，用户已回到首页');
  }

  /// 手动同步用户信息
  /// 
  /// 供其他页面或控制器调用的公开方法
  /// 例如：用户在个人信息页面修改信息后，可以调用此方法同步到主页
  void syncUserProfile() {
    debugPrint('$tag: 📡 手动触发用户信息同步');
    _syncUserProfile();
  }

  // 7. 生命周期方法
  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: onInit');
    
    // 初始化服务依赖
    _userService = Get.find<UserService>();
    
    // 初始化生命周期管理器
    _initLifecycleCallbacks();
    
    debugPrint('$tag: onInit完成 - 当前索引: ${currentIndex.value}');
  }

  @override
  void onReady() {
    super.onReady();
    debugPrint('$tag: onReady');
    // 在这里进行数据初始化
    _initData();
  }

  @override
  void onClose() {
    debugPrint('$tag: onClose');
    
    // 清理生命周期回调
    _clearLifecycleCallbacks();
    
    super.onClose();
  }
}
